#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct listnode
{
	int id ;
	struct slist *next ;			
}listnode_s;
 

listnode_s* create_node(int data)
{
	listnode_s *p = malloc(sizeof(listnode_s));
	if(NULL == p)
	{
		printf("malloc error!\n");
		return NULL ;
	}
	memset(p,0,sizeof(listnode_s));	//由于结构体在未初始化的时候一样是脏数据，所以要清 
	p->id = data ; 	        //初始化第一个节点 
	p->next = NULL ;	    //将节点的后继指针设置为NULL 
    return p;
}
 
//尾插
void tail_insert(listnode_s *pH , listnode_s *new)
{
	
	listnode_s *p = pH ;	//获取当前的位置 
	while(NULL != p->next)  //如果当前位置的下一个节点不为空 
	{
		p = p->next ;       //移动到下一个节点 
	}
	p->next = new ;         //此时直接把新插入的节点赋值给NULL这个位置 
}
//链表的头插 

listnode_s* top_insert(listnode_s *pH , listnode_s *new)
{
	listnode_s *p = pH ;


	new->next=p;
	return new;
//	new->next = p->next ;
//	p->next = new ;

	
}

void print_node(listnode_s *pH)
{
	listnode_s *p = pH ;

	while(NULL != p)	//如果当前位置的下一个节点不为空 
	{
		printf("id:%d\n",p->id);
		p = p->next ;
	}

	printf("end\r\n");
}
 
//反转链表
listnode_s* reverse_list(listnode_s* curr)
{
    listnode_s* pre=NULL;
    listnode_s* nex;
    while(curr!=NULL)
    { 
        nex=curr->next;
        curr->next = pre;
        pre=curr;
        curr=nex;
    }
    return pre;
}

/***删除节点
 * para :
 * pH 这个节点所在的链表的头节点
 * data 要删除节点的数据
*/
int detele_node(listnode_s * pH , int data)
{
	listnode_s *p = pH ;
	listnode_s *prev = NULL;
	
	while(NULL != p->next)
	{
		prev = p ;		
		p = p->next ; 	 
		
		if(p->id == data)//判断，找到了要删除的数据  
		{
			//两种情况，一种是普通节点，还有一种是尾节点
			if(p->next != NULL)  
			{
				prev->next = p->next ;
				free(p);
			}
			else 
			{
				prev->next = NULL ; //将这个尾节点的上一个节点的指针域指向空 
				free(p); 
			}
			return 0  ;
		}
	}
	printf("no Node to detele\n");
	return -1 ;
}

// typedef struct listnode
// {
// 	int id ;
// 	struct slist *next ;			
// }listnode_s;
 
/** */
//Definition for singly-linked list.
// struct ListNode 
// {
//     int val;
//     struct ListNode *next;
// };


//删除链表的中间节点
struct listnode* deleteMiddle(struct listnode* head) 
{
	int leng=0;
	int i=1;
	struct listnode* p1 = head;
	struct listnode* p = head;
	while(p1!=NULL)
	{
		leng++;
		p1=p1->next;
	}
	printf("leng is %d\n",leng);
	struct listnode* pre ;
	
	while(1)
	{
		pre=p;
		
		p=p->next;
		i++;
		printf("i is %d, ",i);
		printf("p-data is %d\n",p->id);
		if(i==leng/2)
		{
			pre->next=p->next;
			free(p);
			return;
		}
	}
}
//leecode 练习题奇偶链表
struct listnode* oddEvenList(struct listnode* head) 
{
 	if (head == NULL) 
	{
        return head;
    }
	
	struct listnode*  evenHead = head->next;
	struct listnode* odd=head;
	struct listnode* even=evenHead;
    while(even!=NULL&&even->next!=NULL)
	{
		odd->next=even->next;
		odd=odd->next;
		even->next=odd->next;
		even=even->next;
 
	}
	odd->next=evenHead;
	return head;
}
//leecode 链表最大孪生和
int pairSum(struct listnode* head) 
{
	
	int i=0,j=0,l=0;
	struct listnode* p=head;
	struct listnode* p2=head;

	int max=0;
	while(p!=NULL)
	{
		i++;
		p=p->next;
	}

    int arr[i];
	
    int arr2[i];
	while(p2!=NULL)
	{
		arr[j]=p2->id;
		j++;
		p2=p2->next;
	}

	for(int k=0;k<=(i/2)-1;k++)
	{
		arr2[l]=arr[k]+arr[i-1-k];
		l++;
	}

	for(int m=0;m<l;m++)
	{
		
		if(arr2[m]>max)
		{
			max=arr2[m];
		}
	}

	return max;
}

int main(int argc , char **argv) 
{

	int i ;
	listnode_s *header = create_node(4);  // 申请节点赋值1
 	listnode_s* header2;
	int ma;
	// for(i = 2 ; i < 5 ; i++)
	// {
	// 	tail_insert(header,create_node(i)); //尾插
	// }
	tail_insert(header,create_node(2)); //尾插
	tail_insert(header,create_node(2)); //尾插
	tail_insert(header,create_node(3)); //尾插
	print_node(header);	//打印
	ma=pairSum(header);
	printf("\nre is %d\n",ma);
 	// tail_insert(header,create_node(10));	//尾节点添加
	// print_node(header);  		//打印
	// header2=oddEvenList(header)	;		
	// print_node(header);  		//打印
	// print_node(header2);  		//打印

	// printf("\r\nhead inset\r\n");
	// header2=top_insert(header,create_node(99));
	// print_node(header2);  					//打印

	// detele_node(header2,3);					//删除值为3的节点
	// print_node(header2);  					//打印
	// printf("\r\ndelet middle\r\n");
	// deleteMiddle(header2);
	// print_node(header2);  					//打印



	return 0 ;
}